using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using Newtonsoft.Json;
using System.Linq;
using System;
using Newtonsoft.Json.Linq;
using UnityEngine.AI;

public class Wei_Scout : MonoBehaviour
{
    // 单例模式
    public static Wei_Scout Instance { get; private set; }

    // 引用DeepSeek对话管理器和将军控制器
    [SerializeField] private Wei_DeepSeekDialogueManager deepSeekManager;
    [SerializeField] private Wei_General_Controller generalController;

    // 侦察兵的速度和状态
    [SerializeField] private float moveSpeed = 5f;
    [SerializeField] private float approachDistance = 1.5f; // 接近将军的距离
    private bool isDelivering = false;

    // NavMesh导航相关
    private NavMeshAgent agent;
    [Header("巡航设置")]
    [SerializeField] private float patrolSpeed = 3.5f;     // 巡航速度
    [SerializeField] private float runSpeed = 5f;          // 任务执行速度
    [SerializeField] private float arrivalDistance = 0.5f; // 到达目标的距离阈值
    [SerializeField] private float generalApproachDistance = 0.5f; // 接近将军的距离阈值，避免碰撞
    [SerializeField] private float waitTime = 2f;          // 每个巡航点停留时间
    [SerializeField] private bool autoPatrol = true;       // 是否自动巡航
    [SerializeField] private string[] patrolPoints;        // 巡航点名称数组
    private int currentPatrolIndex = 0;                    // 当前巡航点索引
    private bool isWaiting = false;                        // 是否正在等待
    private Coroutine patrolCoroutine;                     // 巡航协程

    [Header("当前状态")]
    [SerializeField] private string currentState = "空闲"; // 当前状态
    [SerializeField] private string currentTarget = "";    // 当前目标

    // 当前任务（可在监视窗口查看）
    [Header("当前传递的命令信息")]
    [SerializeField] private string currentGeneralName; // 当前将军名称
    [SerializeField] private string currentDestination; // 当前目的地
    [SerializeField] private string currentAction;      // 当前行为
    [SerializeField] private string currentFormation;   // 当前阵型
    private Wei_GeneralDecision currentDecision = null;
    private Transform targetGeneral = null;
    private Vector3 originalPosition;

    // 监视变量
    [Header("命令队列状态")]
    [SerializeField] private int queuedCommandsCount; // 队列中的命令数量
    [SerializeField] private int stackCommandsCount;   // 栈中的命令数量

    // 将军游戏对象引用
    [SerializeField] private GameObject zhuGongObject;
    [SerializeField] private GameObject xuChuObject;
    [SerializeField] private GameObject xiaHouDunObject;
    [SerializeField] private GameObject caoRenObject;
    [SerializeField] private GameObject xuHuangObject;

    // 最后处理的决策回合
    private int lastProcessedDecisionTurn = 0;

    // 队列存储待处理的决策
    private Queue<Wei_GeneralDecision> decisionsQueue = new Queue<Wei_GeneralDecision>();

    [Header("主公设置")]
    [SerializeField] private GameObject caoCaoObject;      // 曹操对象引用，传递完命令后返回到主公身边
    [SerializeField] private float returnToLordSpeed = 6f; // 返回主公身边的速度

    void Awake()
    {
        // 实现单例模式
        if (Instance == null)
        {
            Instance = this;
            DontDestroyOnLoad(gameObject);
        }
        else if (Instance != this)
        {
            Destroy(gameObject);
        }

        // 保存初始位置
        originalPosition = transform.position;
    }

    void Start()
    {
        // 自动查找组件
        if (deepSeekManager == null) deepSeekManager = FindObjectOfType<Wei_DeepSeekDialogueManager>();
        if (generalController == null) generalController = FindObjectOfType<Wei_General_Controller>();

        // 查找将军对象
        if (zhuGongObject == null) zhuGongObject = FindObjectOfType<Wei_ZhuGong>()?.gameObject;
        if (xuChuObject == null) xuChuObject = FindObjectOfType<XuChu>()?.gameObject;
        if (xiaHouDunObject == null) xiaHouDunObject = FindObjectOfType<XiaHouDun>()?.gameObject;
        if (caoRenObject == null) caoRenObject = FindObjectOfType<CaoRen>()?.gameObject;
        if (xuHuangObject == null) xuHuangObject = FindObjectOfType<XuHuang>()?.gameObject;

        // 初始化NavMeshAgent
        agent = GetComponent<NavMeshAgent>();
        if (agent != null)
        {
            agent.updateRotation = false;
            agent.updateUpAxis = false;
            agent.speed = patrolSpeed;
            agent.stoppingDistance = arrivalDistance;
            agent.isStopped = false; // 确保NavMeshAgent一开始不是停止状态
            agent.avoidancePriority = 50; // 设置避障优先级

            // 如果游戏对象不在NavMesh上，尝试将其放置到最近的NavMesh上
            NavMeshHit hit;
            if (NavMesh.SamplePosition(transform.position, out hit, 5.0f, NavMesh.AllAreas))
            {
                transform.position = hit.position;
            }

            Debug.Log("【侦察兵】NavMeshAgent已初始化，位置已校正");
        }
        else
        {
            Debug.LogError("【侦察兵】未找到NavMeshAgent组件，请添加该组件");
            // 尝试添加NavMeshAgent组件
            agent = gameObject.AddComponent<NavMeshAgent>();
            if (agent != null)
            {
                agent.updateRotation = false;
                agent.updateUpAxis = false;
                agent.speed = patrolSpeed;
                agent.stoppingDistance = arrivalDistance;
                agent.isStopped = false;
                Debug.Log("【侦察兵】自动添加了NavMeshAgent组件");
            }
        }

        // 检查是否设置了巡航点
        if (patrolPoints == null || patrolPoints.Length == 0)
        {
            Debug.LogWarning("【侦察兵】未设置巡航点，将使用默认巡航点");
            // 尝试使用场景中名称包含"Patrol"的对象作为默认巡航点
            GameObject[] possiblePatrolPoints = GameObject.FindGameObjectsWithTag("Respawn");
            if (possiblePatrolPoints.Length > 0)
            {
                List<string> pointNames = new List<string>();
                foreach (var point in possiblePatrolPoints)
                {
                    pointNames.Add(point.name);
                }
                patrolPoints = pointNames.ToArray();
                Debug.Log($"【侦察兵】自动设置了 {patrolPoints.Length} 个默认巡航点");
            }
        }

        // 如果设置了自动巡航，启动巡航协程
        if (autoPatrol && patrolPoints != null && patrolPoints.Length > 0)
        {
            Debug.Log($"【侦察兵】自动巡航已开启，将在 {string.Join(", ", patrolPoints)} 之间巡逻");
            patrolCoroutine = StartCoroutine(PatrolRoutine());
        }
        else
        {
            Debug.LogWarning("【侦察兵】自动巡航未启动，请检查设置");
        }

        // 启动协程定期检查决策栈
        StartCoroutine(CheckDecisionsRoutine());
    }

    void Update()
    {
        // 更新监视变量
        queuedCommandsCount = decisionsQueue?.Count ?? 0;
        stackCommandsCount = deepSeekManager?.jsonStack?.Count ?? 0;
    }

    // 巡航协程
    private IEnumerator PatrolRoutine()
    {
        Debug.Log("【侦察兵】开始巡航");

        // 等待一帧，确保所有初始化完成
        yield return null;

        while (true)
        {
            // 如果正在执行任务，暂停巡航
            if (isDelivering)
            {
                Debug.Log("【侦察兵】正在执行任务，暂停巡航");
                yield return new WaitUntil(() => !isDelivering);
                Debug.Log("【侦察兵】任务完成，恢复巡航");
            }

            // 如果没有巡航点或者正在等待，跳过
            if (patrolPoints == null || patrolPoints.Length == 0 || isWaiting)
            {
                Debug.LogWarning("【侦察兵】巡航点无效或正在等待中");
                yield return new WaitForSeconds(0.5f);
                continue;
            }

            // 确保索引在有效范围内
            if (currentPatrolIndex >= patrolPoints.Length)
            {
                currentPatrolIndex = 0;
            }

            // 获取当前巡航点
            string currentPointName = patrolPoints[currentPatrolIndex];
            GameObject targetPoint = GameObject.Find(currentPointName);

            if (targetPoint != null)
            {
                currentState = "巡航中";
                currentTarget = currentPointName;

                // 设置导航目标
                if (agent != null && agent.isActiveAndEnabled)
                {
                    agent.speed = patrolSpeed;
                    agent.isStopped = false;
                    agent.SetDestination(targetPoint.transform.position);

                    Debug.Log($"【侦察兵】正在前往巡航点: {currentPointName}，坐标: {targetPoint.transform.position}");
                }
                else
                {
                    Debug.LogError("【侦察兵】NavMeshAgent不可用，无法设置巡航目标");
                    yield return new WaitForSeconds(1f);
                    continue;
                }

                // 等待到达目标点
                float timeout = 30f; // 设置超时时间，防止永远无法到达
                float elapsed = 0f;

                while (!IsNearDestination(targetPoint.transform.position) && !isDelivering && elapsed < timeout)
                {
                    // 检查导航状态
                    if (agent.pathStatus == NavMeshPathStatus.PathInvalid)
                    {
                        Debug.LogWarning($"【侦察兵】到达巡航点 {currentPointName} 的路径无效，尝试下一个点");
                        break;
                    }

                    // 更新计时器
                    elapsed += Time.deltaTime;
                    yield return null;
                }

                // 检查是否超时
                if (elapsed >= timeout)
                {
                    Debug.LogWarning($"【侦察兵】前往巡航点 {currentPointName} 超时，尝试下一个点");
                    currentPatrolIndex = (currentPatrolIndex + 1) % patrolPoints.Length;
                    continue;
                }

                // 如果在执行任务，跳过等待
                if (isDelivering) continue;

                // 到达巡航点，等待一段时间
                Debug.Log($"【侦察兵】已到达巡航点: {currentPointName}，等待 {waitTime} 秒");
                currentState = "巡航点等待";

                if (agent != null && agent.isActiveAndEnabled)
                {
                    agent.isStopped = true;
                }

                isWaiting = true;
                yield return new WaitForSeconds(waitTime);
                isWaiting = false;

                // 前往下一个巡航点
                currentPatrolIndex = (currentPatrolIndex + 1) % patrolPoints.Length;
            }
            else
            {
                Debug.LogWarning($"【侦察兵】未找到巡航点对象: {currentPointName}，尝试下一个点");
                currentPatrolIndex = (currentPatrolIndex + 1) % patrolPoints.Length;
                yield return new WaitForSeconds(0.5f);
            }
        }
    }

    // 检查是否接近目标位置
    private bool IsNearDestination(Vector3 destination)
    {
        float distance = Vector3.Distance(transform.position, destination);

        // 使用不同的距离阈值，取决于目标是否为将军
        float thresholdDistance = destination == targetGeneral?.position ? generalApproachDistance : arrivalDistance;
        bool isNear = distance <= thresholdDistance;

        if (isNear)
        {
            Debug.Log($"【侦察兵】已接近目标位置，距离: {distance:F2}，阈值: {thresholdDistance:F2}");
        }

        return isNear;
    }

    // 定期检查决策栈，提取新决策
    private IEnumerator CheckDecisionsRoutine()
    {
        Debug.Log("【侦察兵】启动决策检查协程");

        // 首次启动时尝试提取所有决策
        if (!isDelivering)
        {
            Debug.Log("【侦察兵】首次检查决策栈");
            CheckAndProcessNextDecision();
        }

        while (true)
        {
            // 如果当前没有在执行任务，且队列为空，则尝试从栈中提取新决策
            if (!isDelivering && decisionsQueue.Count == 0)
            {
                Debug.Log("【侦察兵】定期检查：侦察兵空闲，尝试提取新决策");
                CheckAndProcessNextDecision();
            }
            else if (isDelivering)
            {
                Debug.Log("【侦察兵】定期检查：侦察兵正在执行传递任务");
            }
            else if (decisionsQueue.Count > 0)
            {
                Debug.Log($"【侦察兵】定期检查：队列中有{decisionsQueue.Count}个待处理命令，但侦察兵状态异常，重置状态");
                // 如果队列有命令但侦察兵不在执行状态，可能是状态不一致，重置状态并启动传递
                isDelivering = false;
                StartDelivery();
            }

            // 每秒检查一次
            yield return new WaitForSeconds(1f);
        }
    }

    // 检查并处理下一个决策
    private void CheckAndProcessNextDecision()
    {
        // 如果队列中已有决策，直接处理
        if (decisionsQueue.Count > 0)
        {
            StartDelivery();
            return;
        }

        // 队列为空，尝试从决策栈中提取所有决策
        ExtractAllDecisionsFromStack();

        // 如果提取后队列中有决策，开始处理
        if (decisionsQueue.Count > 0)
        {
            StartDelivery();
        }
    }

    // 从决策栈中提取所有决策
    private void ExtractAllDecisionsFromStack()
    {
        if (deepSeekManager == null || deepSeekManager.jsonStack.Count == 0)
        {
            Debug.Log("【侦察兵】决策栈为空，无法提取决策");
            return;
        }

        Debug.Log($"【侦察兵】开始从决策栈中提取全部决策，栈中有 {deepSeekManager.jsonStack.Count} 个决策");

        // 清空当前队列
        decisionsQueue.Clear();

        // 创建一个临时栈来存储所有决策
        Stack<object> tempStack = new Stack<object>();

        // 遍历决策栈的所有决策，从栈顶到栈底
        while (deepSeekManager.jsonStack.Count > 0)
        {
            // 从栈顶获取决策
            var decision = deepSeekManager.jsonStack.Pop();
            Debug.Log("【侦察兵】已从决策栈顶部移除一个决策");

            // 处理决策并添加到队列
            ProcessDecision(decision);

            // 将决策添加到临时栈中（为了保持原始顺序，此处不再添加）
            // tempStack.Push(decision);
        }

        // 不再将决策放回原栈，保持清空状态
        // 以前这里可能会隐式地将决策放回栈中

        Debug.Log($"【侦察兵】完成提取，共解析出 {decisionsQueue.Count} 个有效命令，决策栈已清空");
    }

    // 处理单个决策对象
    private void ProcessDecision(object decisionObj)
    {
        try
        {
            // 将决策对象转换为JSON字符串
            string decisionJson = JsonConvert.SerializeObject(decisionObj);
            Debug.Log($"【侦察兵】处理决策JSON: {decisionJson.Substring(0, Mathf.Min(100, decisionJson.Length))}...");

            // 创建JToken解析JSON
            JToken token = JToken.Parse(decisionJson);

            // 确保我们提取的是关键信息："行为"、"阵型"和"去到哪个地方(where)"
            if (token is JArray jArray)
            {
                // 处理数组格式
                foreach (var item in jArray)
                {
                    ExtractDecisionFromToken(item);
                }
            }
            else if (token is JObject jObject)
            {
                // 处理单个对象或嵌套对象
                // 检查是否本身就是决策对象
                if (HasRequiredDecisionProperties(jObject))
                {
                    ExtractDecisionFromToken(jObject);
                }
                else
                {
                    // 搜索嵌套对象
                    foreach (var prop in jObject.Properties())
                    {
                        if (prop.Value is JArray propArray)
                        {
                            foreach (var item in propArray)
                            {
                                ExtractDecisionFromToken(item);
                            }
                        }
                        else if (prop.Value is JObject propObject)
                        {
                            ExtractDecisionFromToken(propObject);
                        }
                    }
                }
            }
        }
        catch (System.Exception e)
        {
            Debug.LogError($"【侦察兵】处理决策时出错: {e.Message}");
        }
    }

    // 检查是否包含必要的决策属性（至少包含将军名称和目的地）
    private bool HasRequiredDecisionProperties(JToken token)
    {
        if (token is JObject obj)
        {
            // 检查关键属性是否存在
            bool hasGeneralName = obj["将军名称"] != null || obj["哪个将军(who)"] != null;
            bool hasDestination = obj["目的地"] != null || obj["去到哪个地方(where)"] != null;

            return hasGeneralName && hasDestination;
        }
        return false;
    }

    // 从JToken中提取决策并添加到队列
    private void ExtractDecisionFromToken(JToken token)
    {
        try
        {
            if (!HasRequiredDecisionProperties(token))
            {
                return;
            }

            JObject obj = (JObject)token;
            Wei_GeneralDecision decision = new Wei_GeneralDecision();

            // 提取将军名称（支持两种可能的属性名）
            decision.将军名称 = obj["将军名称"]?.ToString() ?? obj["哪个将军(who)"]?.ToString();

            // 提取目的地（支持两种可能的属性名）
            decision.目的地 = obj["目的地"]?.ToString() ?? obj["去到哪个地方(where)"]?.ToString();

            // 提取行为和阵型（这些是核心关注点）
            decision.行为 = obj["行为"]?.ToString() ?? "待命"; // 默认为待命
            decision.阵型 = obj["阵型"]?.ToString() ?? "普通阵型"; // 默认为普通阵型

            // 提取士兵数量为字符串格式，支持"5,5,5"格式
            decision.士兵数量 = obj["士兵数量"]?.ToString() ??
                              obj["带领多少士兵(how many)"]?.ToString() ?? "5,5,5"; // 默认值为"5,5,5"

            decision.出发地点 = obj["出发地点"]?.ToString() ??
                             obj["从哪里出发(where)"]?.ToString() ?? "当前位置";

            // 只有关键字段都有值时才添加到队列
            if (!string.IsNullOrEmpty(decision.将军名称) && !string.IsNullOrEmpty(decision.目的地))
            {
                decisionsQueue.Enqueue(decision);
                Debug.Log($"【侦察兵】已添加对{decision.将军名称}的命令：前往{decision.目的地}，行为：{decision.行为}，阵型：{decision.阵型}，士兵配置：{decision.士兵数量}");
            }
        }
        catch (System.Exception e)
        {
            Debug.LogWarning($"【侦察兵】从token提取决策时出错: {e.Message}");
        }
    }

    // 开始传递命令
    private void StartDelivery()
    {
        if (isDelivering)
        {
            Debug.LogWarning("【侦察兵】已经在执行任务，不能重复启动");
            return;
        }

        if (decisionsQueue.Count == 0)
        {
            Debug.Log("【侦察兵】命令队列为空，无法启动任务");
            return;
        }

        // 从队列取出一个决策
        currentDecision = decisionsQueue.Dequeue();
        if (currentDecision == null)
        {
            Debug.LogError("【侦察兵】队列中的决策无效");
            return;
        }

        // 更新UI显示和监视变量
        currentGeneralName = currentDecision.将军名称;
        currentDestination = currentDecision.目的地;
        currentAction = currentDecision.行为;
        currentFormation = currentDecision.阵型;

        Debug.Log($"【侦察兵】开始执行命令传递: 将军={currentGeneralName}, 目的地={currentDestination}, 行为={currentAction}, 阵型={currentFormation}");

        // 根据将军名称获取目标
        GameObject targetObj = null;
        switch (currentGeneralName)
        {
            case "曹仁":
                targetObj = caoRenObject;
                break;
            case "夏侯敦":
                targetObj = xiaHouDunObject;
                break;
            case "徐晃":
                targetObj = xuHuangObject;
                break;
            case "许褚":
                targetObj = xuChuObject;
                break;
            default:
                Debug.Log($"【侦察兵】未知的将军名称: {currentGeneralName}");
                break;
        }

        if (targetObj == null)
        {
            Debug.Log($"【侦察兵】未找到将军: {currentGeneralName}");
            isDelivering = false;
            // 如果队列中还有命令，继续处理下一个
            if (decisionsQueue.Count > 0)
            {
                StartDelivery();
            }
            return;
        }

        targetGeneral = targetObj.transform;
        isDelivering = true;
        currentState = "传递命令中";

        // 设置NavMeshAgent，为曹仁和夏侯敦设置更高的移动速度
        if (agent != null)
        {
            // 根据将军类型调整移动速度，对于曹仁和夏侯敦使用更高的速度
            if (currentGeneralName == "曹仁" || currentGeneralName == "夏侯敦")
            {
                agent.speed = runSpeed * 1.5f; // 提高50%的速度
            }
            else
            {
                agent.speed = runSpeed;
            }

            agent.isStopped = false;
            agent.SetDestination(targetGeneral.position);
            Debug.Log($"【侦察兵】设置目标位置为将军位置: {targetGeneral.position}，速度: {agent.speed}");
        }
        else
        {
            Debug.LogError("【侦察兵】NavMeshAgent不可用");
        }

        // 启动传递协程
        StartCoroutine(DeliverCommandRoutine());
    }

    // 传递命令协程
    private IEnumerator DeliverCommandRoutine()
    {
        Debug.Log("【侦察兵】开始传递命令协程");

        // 等待NavMeshAgent到达将军附近
        float startTime = Time.time;
        float timeoutDuration = 10f; // 设置10秒超时，避免永久等待

        // 修改判断条件，使用专门的将军接近距离
        while (targetGeneral != null && Vector3.Distance(transform.position, targetGeneral.position) > generalApproachDistance)
        {
            // 检查是否超时
            if (Time.time - startTime > timeoutDuration)
            {
                Debug.LogWarning($"【侦察兵】接近将军 {currentGeneralName} 超时，强制传递命令");
                break;
            }

            // 更新目标位置（将军可能移动）
            if (agent != null && agent.isActiveAndEnabled && !agent.isStopped)
            {
                agent.SetDestination(targetGeneral.position);

                // 检查是否接近将军，如果接近则提前停止
                float currentDistance = Vector3.Distance(transform.position, targetGeneral.position);
                if (currentDistance <= generalApproachDistance * 1.1f) // 稍微提前一点停止
                {
                    Debug.Log($"【侦察兵】接近将军 {currentGeneralName}，距离: {currentDistance:F2}，停止移动");
                    agent.isStopped = true;
                    break;
                }
            }

            yield return new WaitForSeconds(0.1f);
        }

        // 到达将军位置
        if (targetGeneral != null)
        {
            Debug.Log($"【侦察兵】已到达将军位置: {currentGeneralName}");

            // 停止移动
            if (agent != null)
            {
                agent.isStopped = true;
            }

            // 执行命令传递
            DeliverCommand();

            // 等待传递命令的时间（缩短为0.5秒）
            yield return new WaitForSeconds(0.5f);

            // 检查队列中是否还有命令
            if (decisionsQueue.Count > 0)
            {
                Debug.Log($"【侦察兵】队列中还有 {decisionsQueue.Count} 个命令，直接处理下一个");

                // 不返回原位置，直接重置状态
                isDelivering = false;
                targetGeneral = null;
                currentState = "准备下一命令";

                // 启动下一个命令传递
                StartDelivery();
            }
            else
            {
                // 所有命令处理完毕，返回主公位置或继续巡航
                currentState = "返回主公处";

                if (agent != null)
                {
                    agent.isStopped = false;

                    // 设置返回速度
                    agent.speed = returnToLordSpeed;

                    // 确定目标位置（主公位置 > 原始位置 > 巡航）
                    if (zhuGongObject != null)
                    {
                        // 返回主公位置
                        agent.SetDestination(zhuGongObject.transform.position);
                        Debug.Log($"【侦察兵】所有命令已传递，返回主公（曹操）位置: {zhuGongObject.transform.position}");

                        // 等待返回到主公位置
                        float returnTimeout = 20f; // 20秒超时
                        float returnStartTime = Time.time;

                        // 持续更新目标位置（主公可能移动）
                        while (!IsNearDestination(zhuGongObject.transform.position) &&
                               Time.time - returnStartTime < returnTimeout)
                        {
                            // 更新主公位置（主公可能移动）
                            if (agent != null && agent.isActiveAndEnabled && !agent.isStopped)
                            {
                                agent.SetDestination(zhuGongObject.transform.position);
                            }

                            yield return new WaitForSeconds(0.2f);
                        }

                        Debug.Log("【侦察兵】已返回主公身边，任务完成");
                    }
                    else if (autoPatrol && patrolPoints != null && patrolPoints.Length > 0)
                    {
                        Debug.Log("【侦察兵】所有命令已传递，未找到主公，恢复巡航");
                    }
                    else
                    {
                        // 返回原始位置
                        agent.SetDestination(originalPosition);
                        Debug.Log($"【侦察兵】所有命令已传递，未找到主公，返回原始位置: {originalPosition}");

                        // 等待返回到原始位置
                        yield return new WaitUntil(() => IsNearDestination(originalPosition) || Time.time - startTime > 15f);
                    }

                    // 重置状态
                    isDelivering = false;
                    targetGeneral = null;
                    currentGeneralName = "";
                    currentDestination = "";
                    currentAction = "";
                    currentFormation = "";
                    currentState = "空闲";
                }
            }
        }
        else
        {
            // Debug.LogError("【侦察兵】目标将军不存在");

            // 重置状态
            isDelivering = false;
            targetGeneral = null;
            currentGeneralName = "";
            currentDestination = "";
            currentAction = "";
            currentFormation = "";
            currentState = "空闲";

            // 如果队列中还有命令，继续处理
            if (decisionsQueue.Count > 0)
            {
                Debug.Log($"【侦察兵】队列中还有 {decisionsQueue.Count} 个命令，继续处理");
                StartDelivery();
            }
        }
    }

    // 传递命令到将军
    private void DeliverCommand()
    {
        if (currentDecision == null || targetGeneral == null)
        {
            Debug.LogWarning("【侦察兵】无法传递命令：缺少决策或目标将军");
            return;
        }

        Debug.Log($"【侦察兵】正在向{currentDecision.将军名称}传递命令: {currentDecision.行为}，目标地点: {currentDecision.目的地}");

        // 使用通用的将军控制器进行命令传递
        Wei_General_Controller generalController = FindObjectOfType<Wei_General_Controller>();
        if (generalController != null)
        {
            generalController.ApplySingleDecision(currentDecision);
            Debug.Log($"【侦察兵】已通过将军控制器将命令传递给{currentDecision.将军名称}");
        }
        else
        {
            Debug.LogError("【侦察兵】无法找到将军控制器");
        }

        // 播放命令传递的动画或音效（可选）
        // PlayDeliveryAnimation();
    }

    // 手动触发决策提取和传递（可从外部调用）
    public void ForceExtractAndDeliver()
    {
        if (!isDelivering)
        {
            // 先调试决策栈内容
            DebugJsonStackContents();

            // 清空队列并重新提取所有决策
            decisionsQueue.Clear();
            ExtractAllDecisionsFromStack();

            // 开始处理队列
            if (decisionsQueue.Count > 0)
            {
                StartDelivery();
            }
            else
            {
                Debug.Log("【侦察兵】没有发现任何有效命令");
            }
        }
        else
        {
            Debug.Log("【侦察兵】正在执行传递任务，无法立即处理新命令");
        }
    }

    // 调试JsonStack中的内容
    private void DebugJsonStackContents()
    {
        if (deepSeekManager == null || deepSeekManager.jsonStack.Count == 0)
        {
            Debug.LogWarning("【侦察兵调试】决策栈为空，无内容可调试");
            return;
        }

        Debug.Log($"【侦察兵调试】决策栈中有 {deepSeekManager.jsonStack.Count} 个对象");

        // 获取栈顶元素（最新决策）
        var latestDecision = deepSeekManager.jsonStack.Peek();
        string decisionJson = JsonConvert.SerializeObject(latestDecision, Formatting.Indented);

        // 输出完整JSON（分段输出，防止日志被截断）
        Debug.Log("【侦察兵调试】最新决策JSON开始 =====================");

        // 分段输出，每段最多1000字符
        int segmentSize = 1000;
        for (int i = 0; i < decisionJson.Length; i += segmentSize)
        {
            int length = Math.Min(segmentSize, decisionJson.Length - i);
            Debug.Log(decisionJson.Substring(i, length));
        }

        Debug.Log("【侦察兵调试】最新决策JSON结束 =====================");

        // 尝试分析JSON结构
        try
        {
            // 尝试解析为JObject或JArray
            JToken token = JToken.Parse(decisionJson);

            if (token is JObject jObject)
            {
                Debug.Log("【侦察兵调试】JSON是一个对象");

                // 输出所有顶级属性
                foreach (var prop in jObject.Properties())
                {
                    Debug.Log($"【侦察兵调试】属性: {prop.Name} - 类型: {prop.Value.Type}");

                    // 如果是数组属性，输出数组长度
                    if (prop.Value.Type == JTokenType.Array)
                    {
                        JArray array = (JArray)prop.Value;
                        Debug.Log($"【侦察兵调试】数组 {prop.Name} 包含 {array.Count} 个元素");

                        // 输出数组中第一个元素的示例
                        if (array.Count > 0)
                        {
                            string elementJson = array[0].ToString();
                            Debug.Log($"【侦察兵调试】数组第一个元素示例: {elementJson.Substring(0, Math.Min(100, elementJson.Length))}...");
                        }
                    }
                }
            }
            else if (token is JArray jArray)
            {
                Debug.Log($"【侦察兵调试】JSON是一个数组，包含 {jArray.Count} 个元素");

                // 输出数组中第一个元素的示例
                if (jArray.Count > 0)
                {
                    string elementJson = jArray[0].ToString();
                    Debug.Log($"【侦察兵调试】数组第一个元素示例: {elementJson.Substring(0, Math.Min(100, elementJson.Length))}...");
                }
            }
        }
        catch (Exception e)
        {
            Debug.LogError($"【侦察兵调试】解析JSON结构时出错: {e.Message}");
        }
    }
}